home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / INTERNET / BROWSERS / GLUESTIK.ZOO / testit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-07  |  14.9 KB  |  561 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <osbind.h>
  5. #include <mintbind.h>
  6. #include <time.h>
  7. #include <errno.h>
  8. #include <sys/time.h>
  9. #include <sys/types.h>
  10.  
  11. #include "drivers.h"
  12. #include "transprt.h"
  13.  
  14. /* These definitions are necessary.  transprt.h has external
  15.  * declarations for them.
  16.  */
  17. DRV_LIST *drivers = (DRV_LIST *)NULL;
  18. TPL *tpl = (TPL *)NULL;
  19.  
  20. /* Put 'STIK' cookie value into drivers */
  21.  
  22. typedef struct {
  23.     long cktag;
  24.     long ckvalue;
  25. } ck_entry;
  26.  
  27. static long init_drivers(void)
  28. {
  29.   long i = 0;
  30.   ck_entry *jar = *((ck_entry **) 0x5a0);
  31.  
  32.   while (jar[i].cktag) {
  33.     if (!strncmp((char *)&jar[i].cktag, CJTAG, 4)) {
  34.       drivers = (DRV_LIST *)jar[i].ckvalue;
  35.       return (0);
  36.     }
  37.     ++i;
  38.   }
  39.   return (0);  /* Pointless return value...  */
  40. }
  41.  
  42. void errtext_test(void)
  43. {
  44.   static int errs[] = {E_NORMAL, E_EOF, E_BADHANDLE, E_CONNECTFAIL,
  45.                -1000 - EWOULDBLOCK, -1000 - ENOMEM, E_NOMEM,
  46.                -999};
  47.   int n;
  48.   char *s;
  49.  
  50.   printf("\nTesting error messages...\n");
  51.   printf("\t[get_err_text = %p]\n", (void *)(tpl->get_err_text));
  52.  
  53.   for (n = 0; n < sizeof(errs)/sizeof(int); n++) {
  54.     s = get_err_text(errs[n]);
  55.     printf("get_err_text(%d) returned \"%s\"\n", errs[n], (s?s:"<<<NULL>>>"));
  56.   }
  57. }
  58.  
  59. void stikvar_test(void)
  60. {
  61.   static char *vars[] = {"ALLOCMEM", "CDVALID", "BOGUSVAR"};
  62.   int n;
  63.   char *s;
  64.  
  65.   printf("\nTesting STiK config vars...\n");
  66.   printf("\t[getvstr = %p]\n", (void *)(tpl->getvstr));
  67.  
  68.   for (n = 0; n < sizeof(vars)/sizeof(char *); n++) {
  69.     s = getvstr(vars[n]);
  70.     printf("getvstr(\"%s\") returns \"%s\"\n", vars[n], (s?s:"<<<NULL>>>"));
  71.   }
  72. }
  73.  
  74. void mem_test(void)
  75. {
  76.   char *mem1, *mem2, *mem3, *mem0;
  77.   static char data[] = "Some test data";
  78.  
  79.   printf("\nTesting the memory pool...\n");
  80.   printf("\t[KRmalloc = %p]\n", (void *)(tpl->KRmalloc));
  81.   printf("\t[KRfree = %p]\n", (void *)(tpl->KRfree));
  82.   printf("\t[KRgetfree = %p]\n", (void *)(tpl->KRgetfree));
  83.   printf("\t[KRrealloc = %p]\n", (void *)(tpl->KRrealloc));
  84.  
  85.   printf("%ld bytes free, largest block %ld bytes\n",
  86.      KRgetfree(0), KRgetfree(1));
  87.   mem1 = KRmalloc(50);
  88.   printf("First KRmalloc(50) returns %p\n", (void *)mem1);
  89.   mem2 = KRmalloc(50);
  90.   printf("Second KRmalloc(50) returns %p\n", (void *)mem2);
  91.   mem3 = KRmalloc(50);
  92.   printf("Third KRmalloc(50) returns %p\n", (void *)mem3);
  93.   printf("%ld bytes free, largest block %ld bytes\n",
  94.      KRgetfree(0), KRgetfree(1));
  95.  
  96.   KRfree(mem2);
  97.   printf("Freed second block; now %ld bytes free, largest block %ld bytes\n",
  98.      KRgetfree(0), KRgetfree(1));
  99.  
  100.   strcpy(mem1, data);
  101.   mem0 = KRrealloc(mem1, 80);
  102.   printf("KRrealloc(80) on first block returns %p (should not have "
  103.      "changed%s)\n",
  104.      mem0, (mem0 == mem1 ? "" : " --- ERROR"));
  105.   printf("Contents of first block has%s changed\n",
  106.      (strcmp(mem0, data) ? "" : " not"));
  107.   printf("Now %ld bytes free, largest block %ld bytes\n",
  108.      KRgetfree(0), KRgetfree(1));
  109.   mem1 = mem0;
  110.  
  111.   mem0 = KRrealloc(mem1, 150);
  112.   printf("KRrealloc(150) on first block returns %p (should have "
  113.      "changed%s)\n",
  114.      mem0, (mem0 != mem1 ? "" : " --- ERROR"));
  115.   printf("Contents of first block has %s\n",
  116.      (strcmp(mem0, data) ? "changed --- ERROR" : "not changed"));
  117.   printf("Now %ld bytes free, largest block %ld bytes\n",
  118.      KRgetfree(0), KRgetfree(1));
  119.  
  120.   mem2 = KRrealloc(NULL, 85);
  121.   printf("KRrealloc(NULL, 85) returns %p (should be where first block "
  122.      "originally was%s)\n",
  123.      mem2, (mem2 == mem1 ? "" : " --- ERROR"));
  124.   printf("New block was %s\n", (*mem2 ? "not erased --- ERROR" : "erased"));
  125.   printf("Now %ld bytes free, largest block %ld bytes\n",
  126.      KRgetfree(0), KRgetfree(1));
  127.  
  128.   KRfree(mem0);
  129.   KRfree(mem2);
  130.   KRfree(mem3);
  131.   printf("All blocks freed; now %ld bytes free, largest block %ld bytes\n",
  132.      KRgetfree(0), KRgetfree(1));
  133. }
  134.  
  135. void resolver_test(void)
  136. {
  137.   char *realname;
  138.   unsigned long addrs[5];
  139.   int n, i, j;
  140.   static char *names[] = {"localhost", "goldfinch.cs.duke.edu",
  141.             "www.w3.org", "bogus.address"};
  142.  
  143.   printf("\nTesting the DNS resolver...\n");
  144.   printf("\t[resolve = %p]\n", (void *)(tpl->resolve));
  145.  
  146.   for (j = 0; j < sizeof(names)/sizeof(char *); j++) {
  147.     n = resolve(names[j], &realname, addrs, 5);
  148.     if (n < 0) {
  149.       printf("resolve(\"%s\") returned error code %d: %s\n",
  150.          names[j], n, get_err_text(n));
  151.     } else {
  152.       printf("resolve(\"%s\") returned %d addresses: ", 
  153.          names[j], n);
  154.       for (i = 0; i < n; i++)
  155.     printf(" %lu.%lu.%lu.%lu", addrs[i]>>24, (addrs[i]>>16)&0xFFL,
  156.            (addrs[i]>>8)&0xFFL, addrs[i]&0xFFL);
  157.       printf("\n\tReal hostname was %s\n", realname);
  158.       KRfree(realname);
  159.     }
  160.   }
  161. }
  162.  
  163. void tcp_test(void)
  164. {
  165.   unsigned long hostaddr;
  166.   int fd, ret, nchars = 0;
  167.   NDB *N;
  168.   static char finger_host[] = "goldfinch.cs.duke.edu",
  169.           finger_name[] = "dsb\r\n";
  170.   char buf[10];
  171.  
  172.   printf("\nTesting the TCP functions...\n");
  173.   printf("\t[TCP_open = %p]\n", (void *)(tpl->TCP_open));
  174.   printf("\t[TCP_close = %p]\n", (void *)(tpl->TCP_close));
  175.   printf("\t[TCP_send = %p]\n", (void *)(tpl->TCP_send));
  176.   printf("\t[CNbyte_count = %p]\n", (void *)(tpl->CNbyte_count));
  177.   printf("\t[CNget_char = %p]\n", (void *)(tpl->CNget_char));
  178.   printf("\t[CNget_block = %p]\n", (void *)(tpl->CNget_block));
  179.   printf("\t[CNget_NDB = %p]\n", (void *)(tpl->CNget_NDB));
  180.  
  181.   ret = resolve(finger_host, NULL, &hostaddr, 1);
  182.   if (ret < 0) {
  183.     printf("resolve(\"%s\") returned error code %d: %s\n",
  184.        finger_host, ret, get_err_text(ret));
  185.     return;
  186.   }
  187.  
  188.   fd = TCP_open(hostaddr, 79, 0, 0);
  189.   if (fd < 0) {
  190.     printf("TCP_open() returned error code %d: %s\n", fd, get_err_text(fd));
  191.     return;
  192.   } else {
  193.     printf("TCP_open() returns socket handle %d\n", fd);
  194.   }
  195.  
  196.   ret = TCP_send(fd, finger_name, strlen(finger_name));
  197.   if (ret < 0) {
  198.     printf("TCP_send() returned error code %d: %s\n", ret, get_err_text(ret));
  199.     TCP_close(fd, 0);
  200.     return;
  201.   }
  202.  
  203.   ret = CNbyte_count(fd);
  204.   if (ret < 0) {
  205.     printf("CNbyte_count() returned error code %d: %s\n", ret, get_err_text(ret));
  206.   } else {
  207.     printf("CNbyte_count() reports %d bytes waiting on socket %d\n",
  208.        ret, fd);
  209.   }
  210.  
  211.   ret = CNget_block(fd, buf, 10);    /* should be able to get at least
  212.                        this much */
  213.   if (ret < 0) {
  214.     printf("CNget_block() returned error code %d: %s\n", ret, get_err_text(ret));
  215.   } else {
  216.     printf("CNget_block() read %d bytes from socket %d\n", ret, fd);
  217.   }
  218.  
  219.   {
  220.     int ret2 = CNbyte_count(fd);
  221.  
  222.     if (ret2 < 0) {
  223.       printf("CNbyte_count() returned error code %d: %s\n",
  224.          ret2, get_err_text(ret2));
  225.     } else {
  226.       printf("Now, CNbyte_count() reports %d bytes waiting on socket %d\n",
  227.          ret2, fd);
  228.     }
  229.   }
  230.  
  231.   N = CNget_NDB(fd);
  232.   if (!N) {
  233.     printf("CNget_NDB() read nothing\n");
  234.   } else {
  235.     printf("CNget_NDB() read %u bytes from socket %d\n", N->len, fd);
  236.   }
  237.  
  238.   /* Now, print whatever these two managed to read and get the rest with
  239.      CNget_char(). */
  240.   if (ret > 0)
  241.     printf("%.*s", ret, buf);
  242.   if (N) {
  243.     printf("%.*s", (int)N->len, N->ndata);
  244.     if (N->ptr)
  245.       KRfree(N->ptr);
  246.     KRfree((char *)N);
  247.   }
  248.  
  249.   for (;;) {
  250.     ret = CNget_char(fd);
  251.     if (ret == E_EOF)
  252.       break;
  253.     if (ret == E_NODATA)
  254.       continue;
  255.     if (ret < 0) {
  256.       printf("\nCNget_char() returned error code %d: %s\n",
  257.          ret, get_err_text(ret));
  258.       break;
  259.     }
  260.     nchars++;
  261.     putchar(ret);
  262.   }
  263.   printf("\nRead %d bytes via CNget_char()\n", nchars);
  264.  
  265.   ret = CNbyte_count(fd);
  266.   if (ret < 0) {
  267.     printf("After EOF, CNbyte_count() returned error code %d: %s\n",
  268.        ret, get_err_text(ret));
  269.   } else {
  270.     printf("After EOF, CNbyte_count() reports %d bytes waiting on socket %d\n",
  271.        ret, fd);
  272.   }
  273.   ret = Finstat(fd);
  274.   if (ret < 0) {
  275.     printf("After EOF, Finstat() returned error code %d: %s\n",
  276.        ret, strerror(-ret));
  277.   } else {
  278.     printf("After EOF, Finstat() reports %d bytes waiting on socket %d\n",
  279.        ret, fd);
  280.   }
  281.  
  282.   {
  283.     fd_set except_set;
  284.     struct timeval T;
  285.  
  286.     FD_ZERO(&except_set);
  287.     FD_SET(fd, &except_set);
  288.     T.tv_sec = T.tv_usec = 0;
  289.     ret = select(fd + 1, NULL, NULL, &except_set, &T);
  290.     if (ret > 0) {
  291.       printf("After EOF, select() reported exceptional state on socket %d\n",
  292.          fd);
  293.     } else if (ret == 0) {
  294.       printf("After EOF, select() did not report exceptional state on socket %d\n",
  295.          fd);
  296.     } else {
  297.       printf("After EOF, select() returned error code %d: %s\n", errno,
  298.          strerror(errno));
  299.     }
  300.   }
  301.  
  302.   ret = TCP_close(fd, 0);
  303.   if (ret < 0) {
  304.     printf("TCP_close(%d) returned error code %d: %s\n",
  305.        fd, ret, get_err_text(ret));
  306.   }
  307. }
  308.  
  309. void NDB_test(void)
  310. {
  311.   unsigned long hostaddr;
  312.   int fd, ret;
  313.   NDB *N;
  314.   static char finger_host[] = "goldfinch.cs.duke.edu",
  315.           finger_name[] = "dsb\r\n";
  316.  
  317.   printf("\nTesting the TCP functions, with CNget_NDB() reads...\n");
  318.   printf("\t[TCP_open = %p]\n", (void *)(tpl->TCP_open));
  319.   printf("\t[TCP_close = %p]\n", (void *)(tpl->TCP_close));
  320.   printf("\t[TCP_send = %p]\n", (void *)(tpl->TCP_send));
  321.   printf("\t[CNbyte_count = %p]\n", (void *)(tpl->CNbyte_count));
  322.   printf("\t[CNget_NDB = %p]\n", (void *)(tpl->CNget_NDB));
  323.  
  324.   ret = resolve(finger_host, NULL, &hostaddr, 1);
  325.   if (ret < 0) {
  326.     printf("resolve(\"%s\") returned error code %d: %s\n",
  327.        finger_host, ret, get_err_text(ret));
  328.     return;
  329.   }
  330.  
  331.   fd = TCP_open(hostaddr, 79, 0, 0);
  332.   if (fd < 0) {
  333.     printf("TCP_open() returned error code %d: %s\n", fd, get_err_text(fd));
  334.     return;
  335.   } else {
  336.     printf("TCP_open() returns socket handle %d\n", fd);
  337.   }
  338.  
  339.   {
  340.     fd_set rfd, wfd;
  341.     struct timeval T;
  342.  
  343.     FD_ZERO(&rfd);
  344.     FD_SET(fd, &rfd);
  345.     FD_ZERO(&wfd);
  346.     FD_SET(fd, &wfd);
  347.     T.tv_sec = T.tv_usec = 0;
  348.     ret = select(fd + 1, &rfd, &wfd, NULL, &T);
  349.     if (ret > 0) {
  350.       printf("Initially, select() reported %s state on socket %d\n",
  351.     (FD_ISSET(fd, &rfd) && FD_ISSET(fd, &wfd) ? "read and write" :
  352.                    FD_ISSET(fd, &rfd) ? "read" :
  353.                    FD_ISSET(fd, &wfd) ? "write" : "strange"),
  354.     fd
  355.       );
  356.     } else if (ret == 0) {
  357.       printf("Initially, select() reported no read or write state on socket %d\n",
  358.          fd);
  359.     } else {
  360.       printf("Initially, select() returned error code %d: %s\n", errno,
  361.          strerror(errno));
  362.     }
  363.   }
  364.  
  365.   ret = TCP_send(fd, finger_name, strlen(finger_name));
  366.   if (ret < 0) {
  367.     printf("TCP_send() returned error code %d: %s\n", ret, get_err_text(ret));
  368.     TCP_close(fd, 0);
  369.     return;
  370.   }
  371.  
  372.   ret = CNbyte_count(fd);
  373.   if (ret < 0) {
  374.     printf("CNbyte_count() returned error code %d: %s\n", ret, get_err_text(ret));
  375.   } else {
  376.     printf("CNbyte_count() reports %d bytes waiting on socket %d\n",
  377.        ret, fd);
  378.   }
  379.  
  380.   for (;;) {
  381.     N = CNget_NDB(fd);
  382.     if (N) {
  383.       printf("%.*s", (int)N->len, N->ndata);
  384.       if (N->ptr)
  385.     KRfree(N->ptr);
  386.       KRfree((char *)N);
  387.     }
  388.     ret = CNbyte_count(fd);
  389.     if (ret < 0 && ret != E_NODATA) {
  390.       break;
  391.     }
  392.   }
  393.  
  394.   if (ret < 0) {
  395.     printf("After EOF, CNbyte_count() returned error code %d: %s\n",
  396.        ret, get_err_text(ret));
  397.   } else {
  398.     printf("After EOF, CNbyte_count() reports %d bytes waiting on socket %d\n",
  399.        ret, fd);
  400.   }
  401.   ret = Finstat(fd);
  402.   if (ret < 0) {
  403.     printf("After EOF, Finstat() returned error code %d: %s\n",
  404.        ret, strerror(-ret));
  405.   } else {
  406.     printf("After EOF, Finstat() reports %d bytes waiting on socket %d\n",
  407.        ret, fd);
  408.   }
  409.  
  410.   {
  411.     fd_set rfd, wfd;
  412.     struct timeval T;
  413.  
  414.     FD_ZERO(&rfd);
  415.     FD_SET(fd, &rfd);
  416.     FD_ZERO(&wfd);
  417.     FD_SET(fd, &wfd);
  418.     T.tv_sec = T.tv_usec = 0;
  419.     ret = select(fd + 1, &rfd, &wfd, NULL, &T);
  420.     if (ret > 0) {
  421.       printf("After EOF, select() reported %s state on socket %d\n",
  422.     (FD_ISSET(fd, &rfd) && FD_ISSET(fd, &wfd) ? "read and write" :
  423.                    FD_ISSET(fd, &rfd) ? "read" :
  424.                    FD_ISSET(fd, &wfd) ? "write" : "strange"),
  425.     fd
  426.       );
  427.     } else if (ret == 0) {
  428.       printf("After EOF, select() did not report read or write state on socket %d\n",
  429.          fd);
  430.     } else {
  431.       printf("After EOF, select() returned error code %d: %s\n", errno,
  432.          strerror(errno));
  433.     }
  434.   }
  435.  
  436.   ret = TCP_close(fd, 0);
  437.   if (ret < 0) {
  438.     printf("TCP_close(%d) returned error code %d: %s\n",
  439.        fd, ret, get_err_text(ret));
  440.   }
  441. }
  442.  
  443. void CIB_test(void)
  444. {
  445.   CIB *C;
  446.   unsigned long hostaddr;
  447.   int fd, ret;
  448.   static char host_name[] = "goldfinch.cs.duke.edu";
  449.  
  450.   printf("\nTesting CNgetinfo()...\n");
  451.   printf("\t[CNgetinfo = %p]\n", (void *)(tpl->CNgetinfo));
  452.  
  453.   ret = resolve(host_name, NULL, &hostaddr, 1);
  454.   if (ret < 0) {
  455.     printf("resolve(\"%s\") returned error code %d: %s\n",
  456.        host_name, ret, get_err_text(ret));
  457.     return;
  458.   }
  459.  
  460.   fd = TCP_open(hostaddr, 23, 0, 0);
  461.   if (fd < 0) {
  462.     printf("TCP_open() returned error code %d: %s\n", fd, get_err_text(fd));
  463.     return;
  464.   } else {
  465.     printf("TCP_open() returns socket handle %d\n", fd);
  466.   }
  467.  
  468.   C = CNgetinfo(fd);
  469.   if (!C) {
  470.     printf("CNgetinfo(%d) returned NULL\n", fd);
  471.   } else {
  472.     printf("CNgetinfo(%d) returned {%u, %u, %u, %lu.%lu.%lu.%lu}\n",
  473.        fd, C->protocol, C->lport, C->rport,
  474.        (C->rhost>>24), (C->rhost>>16)&0xFFL, (C->rhost>>8)&0xFFL,
  475.        C->rhost&0xFFL);
  476.   }
  477.  
  478.   ret = TCP_close(fd, 0);
  479.   if (ret < 0) {
  480.     printf("TCP_close(%d) returned error code %d: %s\n",
  481.        fd, ret, get_err_text(ret));
  482.   }
  483. }
  484.  
  485.  
  486. struct {
  487.   void (*func)(void);
  488.   const char *descr;
  489. } tests[] = {
  490.   {errtext_test, "Test get_err_text()"},
  491.   {stikvar_test, "Test getvstr()"},
  492.   {mem_test, "Test the memory pool"},
  493.   {resolver_test, "Test the DNS resolver"},
  494.   {tcp_test, "Test the TCP functions"},
  495.   {NDB_test, "Test the TCP functions, with CNget_NDB() reads only"},
  496.   {CIB_test, "Test CNgetinfo()"}
  497. };
  498. #define NTESTS (sizeof(tests)/sizeof(*tests))
  499.  
  500. int main(int argc, char *argv[])
  501. {
  502.   int i, n;
  503.  
  504.   Supexec(init_drivers);
  505.   printf("STiK cookie returned a drivers value of %p\n",
  506.      (void *)drivers);
  507.   if (!drivers) {
  508.     printf("Hmph.  That didn't work...\n");
  509.     exit(1);
  510.   }
  511.   printf("\ndrivers = {\"%s\", %p, %p, %p}\n", drivers->magic,
  512.      (void *)(drivers->get_dftab), (void *)(drivers->ETM_exec),
  513.      (void *)(drivers->cfg));
  514.   printf("drivers->cfg = {0x%08lx, 0x%08lx, %u, %u, %u, %u, %u,"
  515.      " %u, %u, %d, %d, %ld, %d}\n",
  516.      drivers->cfg->client_ip,
  517.      drivers->cfg->provider,
  518.      drivers->cfg->ttl,
  519.      drivers->cfg->ping_ttl,
  520.      drivers->cfg->mtu,
  521.      drivers->cfg->mss,
  522.      drivers->cfg->df_bufsize,
  523.      drivers->cfg->rcv_window,
  524.      drivers->cfg->def_rtt,
  525.      drivers->cfg->time_wait_time,
  526.      drivers->cfg->unreach_resp,
  527.      drivers->cfg->cn_time,
  528.      drivers->cfg->cd_valid);
  529.  
  530.   if (strcmp(MAGIC, drivers->magic)) {
  531.     printf("Hmm... drivers->magic should have been \"%s\"\n", MAGIC);
  532.     return 1;
  533.   }
  534.  
  535.   tpl = (TPL *)get_dftab(TRANSPORT_DRIVER);
  536.   printf("get_dftab(\"%s\") returns %p\n", TRANSPORT_DRIVER, (void *)tpl);
  537.   if (!tpl) {
  538.     printf("Well, durnit, what is this about?\n");
  539.     return 1;
  540.   }
  541.   printf("tpl = {\"%s\", \"%s\", \"%s\"}\n", tpl->module, tpl->author,
  542.      tpl->version);
  543.  
  544.   if (argc <= 1) {
  545.     printf("\nYou didn't select any tests.  The available tests are:\n");
  546.     for (i = 0; i < NTESTS; i++)
  547.       printf("\t%d:  %s\n", i + 1, tests[i].descr);
  548.   } else {
  549.     for (i = 1; i < argc; i++) {
  550.       n = atoi(argv[i]);
  551.       if (n == 0 || n > NTESTS) {
  552.     printf("Unknown test \"%s\"\n", argv[i]);
  553.     continue;
  554.       }
  555.       (*tests[n - 1].func)();
  556.     }
  557.   }
  558.  
  559.   return 0;
  560. }
  561.